<!-- 工装标签页组件 -->
<template>
  <div class="fixture-content">
    <div class="fixture-info">
      <div class="info-item">
        <span class="info-label">电量:</span>
        <span class="info-value">{{ batteryLevel }}%</span>
      </div>
      <div class="info-item">
        <span class="info-label">版本号:</span>
        <span class="info-value">{{ versionNumber }}</span>
      </div>
      <div class="info-item">
        <span class="info-label">左脑阻抗:</span>
        <span class="info-value">{{ leftBrainImpedance }}</span>
      </div>
      <div class="info-item">
        <span class="info-label">右脑阻抗:</span>
        <span class="info-value">{{ rightBrainImpedance }}</span>
      </div>
    </div>
    <div class="fixture-buttons">
      <button class="fixture-button impedance-button" @click="handleImpedance" :disabled="!isConnected">
        阻抗
      </button>
      <button class="fixture-button disconnect-button" @click="handleDisconnect" :disabled="!isConnected">
        停止
      </button>
    </div>
  </div>
</template>

<script>
import { handleConnect } from '@/public/ConnectBLE'
import { writeBLEState, ab2hex, checkPackage, convertFloat } from '@/public/BluetoothFun'
import { mapState, mapMutations } from 'vuex'

export default {
  name: 'FixtureTab',

  computed: {
    // 从Vuex状态管理器中映射需要的状态
    ...mapState(['isConnected', 'originalData']),
  }, watch: {
    // 监听连接状态变化
    isConnected(newVal) {
      if (newVal) {
        // 连接成功时，获取电量和版本号
        console.log('蓝牙连接成功，获取电量和版本号')
        this.getBatteryAndVersion()
      } else {
        // 连接断开且不是用户手动断开的情况下，尝试重新连接上一个设备
        if (!this.isManualDisconnect && this.$store.state.deviceId) {
          console.log('连接断开，开始尝试重新连接...')
          // 防止连续多次尝试重连
          if (!this.isReconnecting) {
            this.isReconnecting = true

            // 启动持续重连机制
            this.startReconnection()
          }
        } else if (this.isManualDisconnect) {
          // 重置手动断开标志，以便下次自动断开时能够自动重连
          this.isManualDisconnect = false
          console.log('用户手动断开连接，不尝试重连')
        }
      }
    },

    // 监听蓝牙数据变化，当收到新数据时进行处理
    originalData(newValue) {
      if (!newValue) return

      console.log('工装标签页接收的数据', ab2hex(newValue))
      this.checkFormat(newValue)
    },
  },
  data() {
    return {
      batteryLevel: 0,
      versionNumber: 'V1.0.0',
      leftBrainImpedance: 0,
      rightBrainImpedance: 0,
      measuringImpedance: false, // 是否正在测量阻抗
      impedanceTimeout: null, // 阻抗测量超时定时器
      isReconnecting: false, // 标记是否正在重连中，防止重复重连
      isManualDisconnect: false, // 标记是否是用户手动断开连接
      hasRequestedImpedance: false, // 标记是否已经请求过阻抗数据
      reconnectCount: 0, // 重连尝试次数
      reconnectTimer: null, // 重连定时器
    }
  },

  methods: {
    // 从Vuex映射需要的mutations
    ...mapMutations(['setIsConnected']),

    /**
     * 检查接收到的数据格式是否正确，并进行相应处理
     * @param {ArrayBuffer} array - 接收到的原始数据
     */
    checkFormat(array) {
      let arrays = Array.prototype.slice.call(new Uint8Array(array))
      let myArr = []
      myArr.push(...arrays)

      let res = checkPackage(myArr)
      console.log('工装标签页解析后的数据包:', res)

      // 如果数据类型为0x01，则为阻抗数据
      if (res[3] === 0x01) {
        this.analyticImpedanceData(res)

        // 如果正在测量阻抗，则关闭加载提示并显示成功提示
        if (this.measuringImpedance) {
          // 清除超时定时器
          if (this.impedanceTimeout) {
            clearTimeout(this.impedanceTimeout)
            this.impedanceTimeout = null
          }

          uni.hideLoading()
          this.measuringImpedance = false

          uni.showToast({
            title: '阻抗测量完成',
            icon: 'success',
            duration: 2000,
          })
        }
      }
      // 如果数据类型为0x10，则为电量数据
      else if (res[3] === 0x10) {
        this.analyticBatteryData(res)
      }
      // 如果数据类型为0x15，则为版本号数据
      else if (res[3] === 0x15) {
        this.analyticVersionData(res)
      }
      else {
        console.log('工装标签页接收到其他类型数据:', res[3])
      }
    },

    /**
     * 解析阻抗数据
     * @param {Array} array - 经过初步处理的数据数组
     */
    analyticImpedanceData(array) {
      console.log("arr", array)
      // 解析数据前端部分
      let decode_front = array.slice(4, -3)

      // 获取左脑阻抗值，保留小数点后2位
      let fixL = parseFloat(convertFloat(decode_front.slice(0, 4).reverse()).toFixed(2))
      // 获取右脑阻抗值，保留小数点后2位
      let fixR = parseFloat(convertFloat(decode_front.slice(4, 8).reverse()).toFixed(2))

      console.log('左脑阻抗:', fixL, '右脑阻抗:', fixR)

      // 更新阻抗值
      this.leftBrainImpedance = fixL
      this.rightBrainImpedance = fixR
    },

    /**
     * 解析电量数据
     * @param {Array} array - 经过初步处理的数据数组
     */
    analyticBatteryData(array) {
      // 获取电量值
      let battery = array[4]
      console.log('电量:', battery)

      // 更新电量值
      this.batteryLevel = array[4]
    },

    /**
     * 解析版本号数据
     * @param {Array} array - 经过初步处理的数据数组
     */
    analyticVersionData(array) {


      // 获取版本号
      let version = `V${array[7]}.${array[8]}.${array[9]}`
      console.log('版本号:', version)

      // 更新版本号
      this.versionNumber = version
    },
    /**
   * 处理连接按钮点击
   */
    handleConnect() {
      // 调用蓝牙连接方法，并传入true参数，表示需要自动搜索设备
      handleConnect(true)
        .then(() => {
          // 等待蓝牙连接状态变化
          const checkConnection = setInterval(() => {
            if (this.isConnected) {
              clearInterval(checkConnection)
              console.log('蓝牙连接成功')
              uni.hideLoading()

              // 获取设备信息
              this.getBatteryAndVersion()

              uni.showToast({
                title: '连接成功',
                icon: 'success',
                duration: 2000,
              })
            }
          }, 1000)

          // 设置超时，如果10秒内没有连接成功，就停止等待
          setTimeout(() => {
            clearInterval(checkConnection)
          }, 10000)
        })
        .catch((error) => {
          console.error('蓝牙连接失败：', error)
          uni.hideLoading()
          uni.showToast({
            title: '连接失败，请重试',
            icon: 'none',
            duration: 2000,
          })
        })
    },

    /**
     * 获取电量和版本号
     */
    getBatteryAndVersion() {
      // 获取电量
      setTimeout(() => {
        writeBLEState(10) // 获取电量的指令
      }, 1000)

      // 延迟后获取版本号
      setTimeout(() => {
        writeBLEState(15) // 获取版本号的指令
      }, 1500)
    },

    /**
     * 处理阻抗按钮点击
     */
    handleImpedance() {
      writeBLEState(40)
      // 显示加载提示
      uni.showLoading({
        title: '测量阻抗中...',
      })

      // 设置阻抗测量标志
      this.measuringImpedance = true

      // 标记已请求阻抗数据，用于重连后自动请求
      this.hasRequestedImpedance = true

      // 调用蓝牙通信函数测量阻抗
      // 这里可以根据需要添加延迟
      setTimeout(() => {
        writeBLEState(1) // 测量阻抗的指令
      }, 2000);
    },

    /**
     * 处理停止按钮点击
     */
    handleDisconnect() {
      // 只发送停止指令
      writeBLEState(99);

      // 显示提示
      uni.showToast({
        title: '已停止！',
        icon: 'success',
        duration: 2000,
      })
    },

    /**
     * 启动重连机制
     */
    startReconnection() {
      console.log('启动持续重连机制')
      // 初始化重连计数器，用于显示尝试次数
      this.reconnectCount = 0
      this.reconnectTimer = null

      // 启动重连循环
      this.tryReconnect()
    },

    /**
     * 尝试重新连接设备
     */
    tryReconnect() {
      this.reconnectCount++
      console.log(`正在尝试第 ${this.reconnectCount} 次重连...`)

      // 使用原有的连接方法尝试重连
      handleConnect()
        .then(() => {
          console.log('自动重连成功')
          this.isReconnecting = false

          // 重连成功后，如果之前请求过阻抗数据，自动再次请求
          if (this.hasRequestedImpedance) {
            console.log('检测到之前已请求过阻抗数据，重新请求阻抗...')
            setTimeout(() => {
              writeBLEState(1)
            }, 7000)
          }

          // 重连成功，清除定时器
          if (this.reconnectTimer) {
            clearTimeout(this.reconnectTimer)
            this.reconnectTimer = null
          }
        })
        .catch(err => {
          console.error('自动重连失败:', err)

          // 无论如何都会继续尝试，5秒后再次尝试
          this.reconnectTimer = setTimeout(() => {
            this.tryReconnect()
          }, 5000) // 5秒后再次尝试
        })
    },
  },

  /**
   * 组件销毁前清除定时器
   */
  beforeDestroy() {
    // 清除阻抗测量超时定时器
    if (this.impedanceTimeout) {
      clearTimeout(this.impedanceTimeout)
      this.impedanceTimeout = null
    }
  },

  /**
   * 组件挂载时，如果已连接蓝牙，则获取电量和版本号
   */
  mounted() {
    console.log('工装标签页组件已挂载')
    // 如果已连接蓝牙，则获取电量和版本号
    if (this.isConnected) {
      console.log('组件挂载时已连接蓝牙，获取电量和版本号')
      this.getBatteryAndVersion()
    } else {
      console.log('组件挂载时未连接蓝牙')
    }
  },
}
</script>

<style scoped lang="scss">
.fixture-content {
  display: flex;
  flex-direction: column;
  gap: 30px;
  padding: 20px;
  background-color: #f9f9f9;
  border-radius: 8px;
  height: 240px;

  .fixture-info {
    display: grid;
    grid-template-columns: repeat(2, 1fr);
    gap: 20px;

    .info-item {
      display: flex;
      align-items: center;
      gap: 10px;

      .info-label {
        font-size: 16px;
        color: #666;
        min-width: 80px;
      }

      .info-value {
        font-size: 16px;
        color: #333;
        font-weight: bold;
      }
    }
  }

  .fixture-buttons {
    display: flex;
    justify-content: center;
    gap: 30px;
    margin-top: 20px;

    .fixture-button {
      padding: 10px 30px;
      border: none;
      border-radius: 4px;
      font-size: 16px;
      cursor: pointer;
      transition: all 0.3s ease;

      &:disabled {
        opacity: 0.5;
        cursor: not-allowed;
      }
    }

    .impedance-button {
      background-color: #4a90e2;
      color: white;

      &:hover:not(:disabled) {
        background-color: #3a80d2;
      }
    }

    .disconnect-button {
      background-color: #ff6b6b;
      color: white;

      &:hover:not(:disabled) {
        background-color: #e55b5b;
      }
    }
  }
}
</style>
